package com.example.selfPractise.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JdkProxyDemo {

    interface Foo {
        void foo();
    }

    static class Target implements Foo {

        @Override
        public void foo() {
            System.out.println(" target foo ");
        }
    }

    /**
     * jdk代理只能针对接口进行代理
     * 内部采用asm技术动态生成字节码（）
     *
     * 由于JDK动态代理，底层是采用了asm字节码技术动态生成，我们无法通过debug源码的方式去学习，为了深入了解其原理，不妨模拟下其实现的过程吧
     * @param args
     */
    public static void main(String[] args) {
        Target target = new Target();
        ClassLoader classLoader = JdkProxyDemo.class.getClassLoader();
        Foo proxy = (Foo)Proxy.newProxyInstance(classLoader, new Class[]{Foo.class}, new InvocationHandler() {
            //proxy 代理对象自身
            //method 正在执行的方法
            //方法参数
            //在源码Proxy打断点 输出结果  before、 target foo 、after
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("before");
                Object result = method.invoke(target, args);
                //代理类返回的是目标方法执行的结果
                System.out.println("after");
                return result;
            }
        });
        proxy.foo();   //在此处打断点  输出结果  before、after、before、 target foo 、after

        /*
        接口和实现类；自定义的invocationHandler、自定义的Proxy对象
         */
    }

}
